//poj 3177
/*该算法是R.Tarjan发明的。对图深度优先搜索，定义DFS(u)为u在搜索树（以下简称为树）中被遍历到的次序号。定义Low(u)为u或u的子树中能通过非父子边追溯到的最早的节点，即DFS序号最小的节点。根据定义，则有：

Low(u)=Min
{
DFS(u)
DFS(v) (u,v)为后向边(返祖边) 等价于 DFS(v)<DFS(u)且v不为u的父亲节点
Low(v) (u,v)为树枝边(父子边)
}

一个顶点u是割点，当且仅当满足(1)或(2)
(1) u为树根，且u有多于一个子树。
(2) u不为树根，且满足存在(u,v)为树枝边(或称父子边，即u为v在搜索树中的父亲)，使得DFS(u)<=Low(v)。

一条无向边(u,v)是桥，当且仅当(u,v)为树枝边，且满足DFS(u)<Low(v)。*/
//hdu4005 求桥模板
#define maxn  30000
const int maxe =300000;
int n,m;
int M;
int first[maxn],next[maxe],C[maxe],E[maxe],Ef[maxe];
int flag[maxn];
void _insert(int x,int y,int z)
{
	M++;
	next[M]=first[x];
	first[x]=M;
	E[M]=y;
	Ef[M]=x;
	C[M]=z;
}

void insert(int x,int y,int z)
{
	_insert(x,y,z);
	_insert(y,x,z);
}
void init()
{
	M=-1;
	memset(first,-1,sizeof(first));
}

/**************求桥*****并且缩点到只剩桥边************************/
int root;
int dfn[maxn],low[maxn],belong[maxn],bcnt,dindex;
//belong里面存的就是缩点后每个点指向的缩点后的点
void  dfs(int u,int father)//深搜找时间戳
{
	int v,i,e,x;
	dfn[u]=low[u]=++dindex;
	for(e=first[u]; e!=-1; e=next[e])
	{
		v=E[e];
		if(flag[e]) 
		{
			continue;
		}
		
		flag[e]=flag[e^1]=1;//只是为了重边问题解决
		//这一步只要不要让无向图访问到以前的访问过的边
		//有重边可以用边来判没有重边可以用点来判
		if(!dfn[v])
		{
			dfs(v,u);
			low[u]=min(low[u],low[v]);
		}
		else
		{
				low[u]=min(low[u],dfn[v]);
		}
	}
}
void search(int u)
{
	int e,v;
	for(e=first[u];e!=-1; e=next[e])
	{
		v=E[e];
		
		if(!belong[v])
		{
			if(low[v]>dfn[u])
				belong[v]=++bcnt;//桥的连通图缩点后只保留桥边，点从1到bcnt;
			else
				belong[v]=belong[u];
			search(v);
		}		
	}
}
void bridge()
{
	int i;
	dindex=0;//时间
	bcnt=1;//桥的连通图缩点后只保留桥边，点从1到bcnt;
	root=1; //默认这个连通图变成树是以1为根节点
	memset(dfn,0,sizeof(dfn));
	memset(belong,0,sizeof(belong));
	memset(flag,0,sizeof(flag));
	belong[root]=1;
	
	
	dfs(root,-1);
	
	search(root);
}
/**************求桥*****并且缩点到只剩桥边************************/
struct node
{
	int x,y,z;
	node(){}
	node(int aa,int bb,int cc){x=aa; y=bb; z=cc;}
}a[300010];
bool operator<(const node &a,const node &b)
{
	return a.z>b.z;
}
int f[200010];

int find(int x)
{
	int fa,t=x;
	while(t!=f[t])
	{
		t=f[t];
	}
	fa=t; t=x;
	while(t!=f[t])
	{
		int tp=f[t];
		f[t]=fa;
		t=tp;
	}
	return fa;
}
int in[200010];
int main()
{
	//freopen("in","r",stdin);
	int i,j,k;
	int x,y,z;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		init();
		for(i=0; i<m; i++)
		{
			scanf("%d%d%d",&x,&y,&z);
			insert(x,y,z);
		}
		int u,v;
		bridge();
		clr(in,0);
		int fu,fv,cnt=0;
		for(i=0; i<=M; i+=2)
		{
			u=Ef[i]; v=E[i];
			 fu=belong[u],fv=belong[v];
			if(fu!=fv)
			{
				in[fu]++;
				in[fv]++;
				a[cnt++]=node(fu,fv,C[i]);
			}
		}
		sort(a,a+cnt);		
		int num=0;
		for(i=1; i<=bcnt; i++)
		{
			f[i]=i;
			if(in[i]>2)
				num++;
		}
		int ans=-1;
		if(num>0)
		{
			for(i=0; i<cnt; i++)
			{
				u=a[i].x; v=a[i].y;
				fu=find(u);
				fv=find(v);
				f[fu]=fv;
				
				if(in[fu]>2)
					num--;
				if(in[fv]>2)
					num--;
				in[fv]=in[fu]+in[fv]-2;
				
				if(in[fv]>2)
					num++;
				if(num==0)
				{	
					ans=a[i].z;	
					break;
				}
			}
		}
		printf("%d\n",ans);		
	}
}

